#!/usr/bin/env python3
"""
关键词管理工具
提供图形化界面和命令行工具来管理关键词、模式、权重

这个模块实现了关键词管理系统，用于管理编程问题识别规则库中的关键词、模式、权重等信息。
支持多种操作模式：交互式命令行、批量操作、数据验证等。

主要功能：
1. 模式管理：创建、删除、修改问题识别模式
2. 关键词管理：添加、删除、更新关键词及其权重
3. 数据验证：检查数据完整性和一致性
4. 统计分析：提供规则库的使用统计和性能指标
5. 导入导出：支持规则库的备份和迁移
6. 搜索功能：快速查找关键词和模式

技术特点：
- 多文件管理：keywords.json, patterns.json, weights.json, contexts.json
- 数据同步：确保所有相关文件的一致性
- 错误处理：完善的异常处理和错误提示
- 交互式界面：用户友好的命令行界面

使用场景：
- 规则库维护：日常的关键词和模式管理
- 规则扩展：添加新的问题类型识别规则
- 性能优化：调整关键词权重提升识别准确率
- 数据迁移：规则库的备份和恢复

依赖: json, os, sys, typing, datetime, argparse
"""

import json
import os
import sys
from typing import Dict, List, Any, Optional
from datetime import datetime
import argparse

class KeywordManager:
    """
    关键词管理器
    
    这是项目的核心管理工具，负责管理规则库中的所有关键词、模式、权重等信息。
    提供完整的CRUD操作和数据分析功能。
    
    核心功能：
    1. 模式管理：创建、删除、修改问题识别模式
    2. 关键词管理：添加、删除、更新关键词及其权重
    3. 数据同步：确保多个JSON文件的一致性
    4. 统计分析：提供规则库的使用统计
    5. 数据验证：检查数据完整性和一致性
    6. 导入导出：支持规则库的备份和迁移
    
    文件结构：
    - keywords.json: 存储模式定义和关键词列表
    - patterns.json: 存储模式匹配规则
    - weights.json: 存储关键词权重信息
    - contexts.json: 存储上下文信息
    
    使用场景：
    - 规则库维护和扩展
    - 关键词权重优化
    - 规则库数据迁移
    - 问题类型识别规则管理
    """
    
    def __init__(self, rules_dir: str = "rules"):
        """
        初始化关键词管理器
        
        创建管理器实例并加载所有规则文件。支持自动创建缺失的文件结构。
        
        参数:
            rules_dir (str): 规则文件目录路径，默认为"rules"
                - 如果目录不存在，会自动创建
                - 包含keywords.json, patterns.json, weights.json, contexts.json
                
        属性:
            rules_dir (str): 规则文件目录路径
            keywords_data (Dict): 关键词数据（来自keywords.json）
            patterns_data (Dict): 模式数据（来自patterns.json）
            weights_data (Dict): 权重数据（来自weights.json）
            contexts_data (Dict): 上下文数据（来自contexts.json）
            
        异常处理:
            - 文件不存在时会创建空的数据结构
            - JSON解析错误时会显示错误信息并创建空结构
        """
        self.rules_dir = rules_dir
        self.keywords_data = {}      # 关键词数据
        self.patterns_data = {}      # 模式数据
        self.weights_data = {}       # 权重数据
        self.contexts_data = {}      # 上下文数据
        
        # 确保规则目录存在
        if not os.path.exists(self.rules_dir):
            os.makedirs(self.rules_dir)
            print(f"已创建规则目录: {self.rules_dir}")
        
        # 加载所有数据文件
        self._load_all_data()
    
    def _load_all_data(self):
        """
        加载所有数据文件
        
        从规则目录中加载所有JSON配置文件，包括：
        1. keywords.json: 关键词和模式定义
        2. patterns.json: 模式匹配规则
        3. weights.json: 关键词权重
        4. contexts.json: 上下文信息
        
        如果文件不存在或加载失败，会创建空的数据结构。
        这确保了管理器的健壮性和容错能力。
        
        文件映射:
            keywords -> keywords_data
            patterns -> patterns_data  
            weights -> weights_data
            contexts -> contexts_data
        """
        files = {
            "keywords": "keywords.json",    # 关键词和模式定义文件
            "patterns": "patterns.json",    # 模式匹配规则文件
            "weights": "weights.json",       # 关键词权重文件
            "contexts": "contexts.json"     # 上下文信息文件
        }
        
        # 遍历所有文件进行加载
        for data_type, filename in files.items():
            filepath = os.path.join(self.rules_dir, filename)
            try:
                if os.path.exists(filepath):
                    # 文件存在，加载JSON数据
                    with open(filepath, 'r', encoding='utf-8') as f:
                        setattr(self, f"{data_type}_data", json.load(f))
                    print(f"已加载 {filename}")
                else:
                    # 文件不存在，创建空数据结构
                    setattr(self, f"{data_type}_data", {})
                    print(f"{filename} 不存在，已创建空结构")
            except Exception as e:
                # 加载失败，创建空数据结构
                print(f"加载 {filename} 时出错: {e}")
                setattr(self, f"{data_type}_data", {})
    
    def save_all_data(self):
        """
        保存所有数据文件
        
        将内存中的数据保存到对应的JSON文件中，确保数据持久化。
        这是数据修改后的必要操作，用于将更改写入磁盘。
        
        保存的文件：
        1. keywords.json: 关键词和模式定义
        2. patterns.json: 模式匹配规则
        3. weights.json: 关键词权重
        4. contexts.json: 上下文信息
        
        保存策略：
        - 使用UTF-8编码确保中文支持
        - 使用4空格缩进提高可读性
        - 确保ASCII字符不转义（ensure_ascii=False）
        - 异常处理确保部分文件失败不影响其他文件
        """
        files = {
            "keywords": "keywords.json",    # 关键词和模式定义文件
            "patterns": "patterns.json",     # 模式匹配规则文件
            "weights": "weights.json",       # 关键词权重文件
            "contexts": "contexts.json"      # 上下文信息文件
        }
        
        # 遍历所有数据并保存到文件
        for data_type, filename in files.items():
            filepath = os.path.join(self.rules_dir, filename)
            try:
                # 获取对应的数据
                data = getattr(self, f"{data_type}_data")
                # 保存到JSON文件
                with open(filepath, 'w', encoding='utf-8') as f:
                    json.dump(data, f, ensure_ascii=False, indent=4)
                print(f"已保存 {filename}")
            except Exception as e:
                # 保存失败，显示错误信息
                print(f"保存 {filename} 时出错: {e}")
    
    def list_patterns(self) -> List[str]:
        """
        列出所有模式
        
        获取规则库中所有已定义的问题识别模式名称。
        这些模式用于分类不同类型的编程问题。
        
        返回:
            List[str]: 模式名称列表，按字典序排序
                - 每个模式名称对应一种问题类型
                - 例如：["addition", "subtraction", "string_processing"]
        """
        patterns = self.keywords_data.get('patterns', {})
        return list(patterns.keys())
    
    def get_pattern_info(self, pattern_name: str) -> Dict[str, Any]:
        """
        获取模式详细信息
        
        获取指定模式的完整信息，包括关键词列表、描述、类别、优先级等。
        
        参数:
            pattern_name (str): 模式名称
            
        返回:
            Dict[str, Any]: 模式信息字典，包含：
                - keywords: 关键词列表
                - description: 模式描述
                - category: 模式类别
                - priority: 优先级（1-10）
        """
        patterns = self.keywords_data.get('patterns', {})
        if pattern_name in patterns:
            return patterns[pattern_name]
        return {}
    
    def add_pattern(self, pattern_name: str, keywords: List[str], description: str = "", category: str = "custom", priority: int = 5):
        """
        添加新模式
        
        创建一个新的问题识别模式，用于识别特定类型的编程问题。
        模式包含关键词列表、描述、类别和优先级信息。
        
        参数:
            pattern_name (str): 模式名称，用于唯一标识该模式
            keywords (List[str]): 关键词列表，用于匹配问题描述
            description (str): 模式描述，说明该模式识别的问题类型
            category (str): 模式类别，用于分类管理，默认为"custom"
            priority (int): 优先级（1-10），数值越高优先级越高，默认为5
            
        返回:
            bool: 添加是否成功
                - True: 成功添加新模式
                - False: 模式已存在或添加失败
                
        副作用:
            - 自动更新weights.json文件中的关键词权重
            - 自动更新patterns.json文件中的模式定义
        """
        # 检查模式是否已存在
        if pattern_name in self.keywords_data.get('patterns', {}):
            print(f"模式 '{pattern_name}' 已存在")
            return False
        
        # 添加到关键词数据 - 存储模式定义和关键词列表
        self.keywords_data.setdefault('patterns', {})[pattern_name] = {
            "keywords": keywords,
            "description": description,
            "category": category,
            "priority": priority
        }
        
        # 添加到模式数据 - 存储模式匹配规则
        self.patterns_data.setdefault('patterns', {})[pattern_name] = []
        
        # 更新权重 - 为新关键词设置默认权重
        for keyword in keywords:
            self.weights_data.setdefault('weights', {})[keyword] = 5
        
        print(f"已添加模式 '{pattern_name}'")
        return True
    
    def remove_pattern(self, pattern_name: str):
        """
        删除模式
        
        从规则库中完全删除指定的问题识别模式。
        这会同时删除模式定义、关键词列表和相关权重信息。
        
        参数:
            pattern_name (str): 要删除的模式名称
            
        返回:
            bool: 删除是否成功
                - True: 成功删除模式
                - False: 模式不存在或删除失败
                
        注意:
            - 删除操作不可逆，请谨慎使用
            - 会同时删除该模式下的所有关键词
            - 建议在删除前备份数据
        """
        # 检查模式是否存在
        if pattern_name not in self.keywords_data.get('patterns', {}):
            print(f"模式 '{pattern_name}' 不存在")
            return False
        
        # 从所有数据中删除模式
        del self.keywords_data['patterns'][pattern_name]
        if pattern_name in self.patterns_data.get('patterns', {}):
            del self.patterns_data['patterns'][pattern_name]
        
        print(f"已删除模式 '{pattern_name}'")
        return True
    
    def add_keyword_to_pattern(self, pattern_name: str, keyword: str, weight: int = 5):
        """
        添加关键词到模式
        
        向现有模式添加新的关键词，用于扩展问题识别能力。
        新添加的关键词会自动设置权重信息。
        
        参数:
            pattern_name (str): 目标模式名称
            keyword (str): 要添加的关键词
            weight (int): 关键词权重（1-15），默认为5
                - 1-3: 低权重，辅助识别
                - 4-7: 中等权重，重要识别
                - 8-15: 高权重，核心识别
                
        返回:
            bool: 添加是否成功
                - True: 成功添加关键词
                - False: 模式不存在或关键词已存在
                
        副作用:
            - 自动更新weights.json中的权重信息
            - 关键词会立即生效，无需重启系统
        """
        patterns = self.keywords_data.get('patterns', {})
        # 检查模式是否存在
        if pattern_name not in patterns:
            print(f"模式 '{pattern_name}' 不存在")
            return False
        
        # 检查关键词是否已存在
        if keyword in patterns[pattern_name]['keywords']:
            print(f"关键词 '{keyword}' 已存在于模式 '{pattern_name}'")
            return False
        
        # 添加关键词到模式
        patterns[pattern_name]['keywords'].append(keyword)
        
        # 更新权重信息
        self.weights_data.setdefault('weights', {})[keyword] = weight
        
        print(f"已添加关键词 '{keyword}' 到模式 '{pattern_name}'")
        return True
    
    def remove_keyword_from_pattern(self, pattern_name: str, keyword: str):
        """
        从模式中删除关键词
        
        从指定模式中移除关键词，用于清理不再需要的关键词。
        删除后该关键词将不再参与该模式的问题识别。
        
        参数:
            pattern_name (str): 目标模式名称
            keyword (str): 要删除的关键词
            
        返回:
            bool: 删除是否成功
                - True: 成功删除关键词
                - False: 模式不存在或关键词不存在
                
        注意:
            - 删除关键词不会影响其他模式中的同名关键词
            - 权重信息会保留，以备将来重新使用
            - 建议在删除前确认关键词确实不再需要
        """
        patterns = self.keywords_data.get('patterns', {})
        # 检查模式是否存在
        if pattern_name not in patterns:
            print(f"模式 '{pattern_name}' 不存在")
            return False
        
        # 检查关键词是否存在
        if keyword not in patterns[pattern_name]['keywords']:
            print(f"关键词 '{keyword}' 不存在于模式 '{pattern_name}'")
            return False
        
        # 从模式中删除关键词
        patterns[pattern_name]['keywords'].remove(keyword)
        
        print(f"已从模式 '{pattern_name}' 中删除关键词 '{keyword}'")
        return True
    
    def update_keyword_weight(self, keyword: str, weight: int):
        """
        更新关键词权重
        
        修改指定关键词的权重值，用于优化问题识别的准确性。
        权重越高，该关键词在问题识别中的重要性越大。
        
        参数:
            keyword (str): 要更新权重的关键词
            weight (int): 新的权重值（1-15）
                - 1-3: 低权重，辅助识别
                - 4-7: 中等权重，重要识别  
                - 8-15: 高权重，核心识别
                
        返回:
            bool: 更新是否成功
                - True: 成功更新权重
                - False: 更新失败
                
        使用场景:
            - 优化问题识别准确率
            - 调整关键词重要性
            - 平衡不同关键词的影响
        """
        self.weights_data.setdefault('weights', {})[keyword] = weight
        print(f"已更新关键词 '{keyword}' 的权重为 {weight}")
        return True
    
    def search_keywords(self, query: str) -> List[Dict[str, Any]]:
        """
        搜索关键词
        
        在规则库中搜索包含指定查询字符串的关键词。
        支持模糊匹配，不区分大小写。
        
        参数:
            query (str): 搜索查询字符串
                - 支持部分匹配
                - 不区分大小写
                - 可以搜索关键词的任何部分
                
        返回:
            List[Dict[str, Any]]: 搜索结果列表，每个结果包含：
                - keyword: 匹配的关键词
                - pattern: 所属的模式名称
                - weight: 关键词权重
                - description: 模式描述
                
        搜索策略:
            - 遍历所有模式中的所有关键词
            - 使用不区分大小写的包含匹配
            - 返回所有匹配的结果
        """
        results = []
        patterns = self.keywords_data.get('patterns', {})
        
        # 遍历所有模式搜索关键词
        for pattern_name, pattern_info in patterns.items():
            keywords = pattern_info.get('keywords', [])
            for keyword in keywords:
                # 不区分大小写的包含匹配
                if query.lower() in keyword.lower():
                    # 获取关键词权重
                    weight = self.weights_data.get('weights', {}).get(keyword, 1)
                    # 构建搜索结果
                    results.append({
                        "keyword": keyword,
                        "pattern": pattern_name,
                        "weight": weight,
                        "description": pattern_info.get('description', '')
                    })
        
        return results
    
    def get_statistics(self) -> Dict[str, Any]:
        """
        获取统计信息
        
        提供规则库的详细统计信息，包括模式数量、关键词分布、权重分析等。
        这些统计信息有助于了解规则库的使用情况和优化方向。
        
        返回:
            Dict[str, Any]: 统计信息字典，包含：
                - total_patterns: 总模式数量
                - total_keywords: 总关键词数量
                - patterns_by_category: 按类别统计的模式分布
                - weight_distribution: 权重分布统计
                - most_used_keywords: 最常用的关键词列表
                
        统计内容:
            1. 基础统计：模式总数、关键词总数
            2. 分类统计：按类别统计模式分布
            3. 权重分析：高、中、低权重关键词分布
            4. 使用频率：跨模式使用最多的关键词
        """
        patterns = self.keywords_data.get('patterns', {})
        weights = self.weights_data.get('weights', {})
        
        # 初始化统计结果
        stats = {
            "total_patterns": len(patterns),           # 总模式数量
            "total_keywords": len(weights),            # 总关键词数量
            "patterns_by_category": {},                # 按类别统计
            "weight_distribution": {                   # 权重分布
                "high": 0,      # 高权重 (8-15)
                "medium": 0,     # 中等权重 (4-7)
                "low": 0         # 低权重 (1-3)
            },
            "most_used_keywords": []                   # 最常用关键词
        }
        
        # 按类别统计模式分布
        for pattern_name, pattern_info in patterns.items():
            category = pattern_info.get('category', 'unknown')
            if category not in stats["patterns_by_category"]:
                stats["patterns_by_category"][category] = 0
            stats["patterns_by_category"][category] += 1
        
        # 权重分布统计
        for keyword, weight in weights.items():
            if weight >= 8:
                stats["weight_distribution"]["high"] += 1
            elif weight >= 5:
                stats["weight_distribution"]["medium"] += 1
            else:
                stats["weight_distribution"]["low"] += 1
        
        # 统计最常用的关键词（跨模式使用）
        keyword_counts = {}
        for pattern_name, pattern_info in patterns.items():
            for keyword in pattern_info.get('keywords', []):
                keyword_counts[keyword] = keyword_counts.get(keyword, 0) + 1
        
        # 按使用频率排序，取前10个
        stats["most_used_keywords"] = sorted(keyword_counts.items(), key=lambda x: x[1], reverse=True)[:10]
        
        return stats
    
    def export_patterns(self, filename: str):
        """
        导出模式到文件
        
        将当前规则库中的所有模式导出到指定的JSON文件中。
        用于备份、迁移或分享规则库。
        
        参数:
            filename (str): 导出文件的路径
                - 支持相对路径和绝对路径
                - 文件格式为JSON
                - 如果文件已存在会被覆盖
                
        返回:
            bool: 导出是否成功
                - True: 成功导出
                - False: 导出失败
                
        导出内容:
            - 所有模式定义
            - 关键词列表
            - 模式描述和类别
            - 优先级信息
        """
        try:
            # 导出关键词数据到JSON文件
            with open(filename, 'w', encoding='utf-8') as f:
                json.dump(self.keywords_data, f, ensure_ascii=False, indent=4)
            print(f"已导出模式到 {filename}")
            return True
        except Exception as e:
            print(f"导出模式时出错: {e}")
            return False
    
    def import_patterns(self, filename: str):
        """
        从文件导入模式
        
        从指定的JSON文件中导入模式定义，用于恢复备份或合并规则库。
        导入的模式会与现有模式合并，不会覆盖现有数据。
        
        参数:
            filename (str): 导入文件的路径
                - 支持相对路径和绝对路径
                - 文件格式必须为JSON
                - 文件必须存在且可读
                
        返回:
            bool: 导入是否成功
                - True: 成功导入
                - False: 导入失败
                
        导入策略:
            - 合并模式：新模式会添加到现有模式中
            - 权重设置：导入的关键词会设置默认权重
            - 冲突处理：同名模式会被跳过
        """
        try:
            # 读取导入文件
            with open(filename, 'r', encoding='utf-8') as f:
                imported_data = json.load(f)
            
            # 合并模式数据
            if 'patterns' in imported_data:
                for pattern_name, pattern_info in imported_data['patterns'].items():
                    # 添加新模式到关键词数据
                    self.keywords_data.setdefault('patterns', {})[pattern_name] = pattern_info
                    
                    # 为新关键词设置默认权重
                    for keyword in pattern_info.get('keywords', []):
                        self.weights_data.setdefault('weights', {})[keyword] = 5
            
            print(f"已从 {filename} 导入模式")
            return True
        except Exception as e:
            print(f"导入模式时出错: {e}")
            return False
    
    def validate_data(self) -> List[str]:
        """
        验证数据完整性
        
        检查规则库中数据的完整性和一致性，发现潜在的数据问题。
        这是维护规则库质量的重要工具。
        
        返回:
            List[str]: 错误信息列表
                - 空列表表示没有发现错误
                - 每个字符串描述一个具体的数据问题
                
        验证内容:
            1. 关键词权重检查：确保所有关键词都有权重定义
            2. 模式一致性检查：确保模式在所有文件中都存在
            3. 数据结构检查：验证JSON结构的正确性
            4. 引用完整性检查：确保没有悬空引用
        """
        errors = []
        
        # 检查关键词权重完整性
        patterns = self.keywords_data.get('patterns', {})
        weights = self.weights_data.get('weights', {})
        
        for pattern_name, pattern_info in patterns.items():
            keywords = pattern_info.get('keywords', [])
            for keyword in keywords:
                # 检查关键词是否有权重定义
                if keyword not in weights:
                    errors.append(f"关键词 '{keyword}' 在模式 '{pattern_name}' 中没有权重定义")
        
        # 检查模式数据一致性
        patterns_data = self.patterns_data.get('patterns', {})
        for pattern_name in patterns:
            # 检查模式是否在模式数据中存在
            if pattern_name not in patterns_data:
                errors.append(f"模式 '{pattern_name}' 在模式数据中不存在")
        
        return errors

def interactive_mode():
    """
    交互式模式
    
    提供用户友好的命令行界面，用于管理关键词和模式。
    支持菜单驱动的操作，适合日常维护和探索规则库。
    
    功能菜单:
        1. 列出所有模式
        2. 查看模式详情
        3. 添加新模式
        4. 删除模式
        5. 添加关键词到模式
        6. 从模式中删除关键词
        7. 更新关键词权重
        8. 搜索关键词
        9. 查看统计信息
        10. 验证数据
        11. 保存所有数据
        0. 退出
        
    使用方式:
        - 直接运行脚本进入交互模式
        - 使用 --interactive 参数启动
        - 适合初学者和日常维护
    """
    manager = KeywordManager()
    
    while True:
        print("\n" + "=" * 50)
        print("关键词管理工具")
        print("=" * 50)
        print("1. 列出所有模式")
        print("2. 查看模式详情")
        print("3. 添加新模式")
        print("4. 删除模式")
        print("5. 添加关键词到模式")
        print("6. 从模式中删除关键词")
        print("7. 更新关键词权重")
        print("8. 搜索关键词")
        print("9. 查看统计信息")
        print("10. 验证数据")
        print("11. 保存所有数据")
        print("0. 退出")
        
        choice = input("\n请选择操作 (0-11): ").strip()
        
        if choice == "0":
            print("再见!")
            break
        elif choice == "1":
            # 列出所有模式
            patterns = manager.list_patterns()
            print(f"\n所有模式 ({len(patterns)} 个):")
            for i, pattern in enumerate(patterns, 1):
                print(f"  {i}. {pattern}")
        elif choice == "2":
            # 查看模式详情
            pattern_name = input("请输入模式名称: ").strip()
            info = manager.get_pattern_info(pattern_name)
            if info:
                print(f"\n模式 '{pattern_name}' 详情:")
                print(f"  描述: {info.get('description', '无')}")
                print(f"  类别: {info.get('category', '无')}")
                print(f"  优先级: {info.get('priority', '无')}")
                print(f"  关键词: {info.get('keywords', [])}")
            else:
                print(f"模式 '{pattern_name}' 不存在")
        elif choice == "3":
            # 添加新模式
            pattern_name = input("请输入新模式名称: ").strip()
            description = input("请输入描述: ").strip()
            category = input("请输入类别: ").strip()
            keywords_input = input("请输入关键词 (用逗号分隔): ").strip()
            keywords = [kw.strip() for kw in keywords_input.split(",") if kw.strip()]
            manager.add_pattern(pattern_name, keywords, description, category)
        elif choice == "4":
            # 删除模式
            pattern_name = input("请输入要删除的模式名称: ").strip()
            confirm = input(f"确认删除模式 '{pattern_name}'? (y/N): ").strip().lower()
            if confirm == 'y':
                manager.remove_pattern(pattern_name)
        elif choice == "5":
            # 添加关键词到模式
            pattern_name = input("请输入模式名称: ").strip()
            keyword = input("请输入关键词: ").strip()
            weight = int(input("请输入权重 (默认5): ").strip() or "5")
            manager.add_keyword_to_pattern(pattern_name, keyword, weight)
        elif choice == "6":
            # 从模式中删除关键词
            pattern_name = input("请输入模式名称: ").strip()
            keyword = input("请输入关键词: ").strip()
            manager.remove_keyword_from_pattern(pattern_name, keyword)
        elif choice == "7":
            # 更新关键词权重
            keyword = input("请输入关键词: ").strip()
            weight = int(input("请输入新权重: ").strip())
            manager.update_keyword_weight(keyword, weight)
        elif choice == "8":
            # 搜索关键词
            query = input("请输入搜索关键词: ").strip()
            results = manager.search_keywords(query)
            print(f"\n搜索结果 ({len(results)} 个):")
            for result in results:
                print(f"  {result['keyword']} (模式: {result['pattern']}, 权重: {result['weight']})")
        elif choice == "9":
            # 查看统计信息
            stats = manager.get_statistics()
            print(f"\n统计信息:")
            print(f"  总模式数: {stats['total_patterns']}")
            print(f"  总关键词数: {stats['total_keywords']}")
            print(f"  按类别分布: {stats['patterns_by_category']}")
            print(f"  权重分布: {stats['weight_distribution']}")
            print("  最常用的关键词:")
            for keyword, count in stats['most_used_keywords']:
                print(f"    {keyword}: {count}")
        elif choice == "10":
            # 验证数据
            errors = manager.validate_data()
            if errors:
                print(f"\n发现 {len(errors)} 个错误:")
                for error in errors:
                    print(f"  ❌ {error}")
            else:
                print("\n✓ 数据验证通过，没有发现错误")
        elif choice == "11":
            # 保存所有数据
            manager.save_all_data()
        else:
            print("❌ 无效选择，请重试")

def main():
    """
    主函数
    
    提供命令行接口，支持多种操作模式：
    1. 交互式模式：用户友好的菜单界面
    2. 命令行模式：直接执行特定操作
    3. 批处理模式：适合脚本和自动化
    
    命令行参数:
        --rules-dir: 指定规则文件目录
        --interactive: 启动交互式模式
        --list: 列出所有模式
        --stats: 显示统计信息
        --validate: 验证数据完整性
        
    使用示例:
        python keyword_manager.py                    # 交互式模式
        python keyword_manager.py --list             # 列出模式
        python keyword_manager.py --stats            # 显示统计
        python keyword_manager.py --validate         # 验证数据
        python keyword_manager.py --rules-dir custom # 指定目录
    """
    parser = argparse.ArgumentParser(description="关键词管理工具")
    parser.add_argument("--rules-dir", default="rules", help="规则文件目录")
    parser.add_argument("--interactive", "-i", action="store_true", help="启动交互式模式")
    parser.add_argument("--list", "-l", action="store_true", help="列出所有模式")
    parser.add_argument("--stats", "-s", action="store_true", help="显示统计信息")
    parser.add_argument("--validate", "-v", action="store_true", help="验证数据")
    
    args = parser.parse_args()
    
    # 创建管理器实例
    manager = KeywordManager(args.rules_dir)
    
    if args.interactive:
        # 启动交互式模式
        interactive_mode()
    elif args.list:
        # 列出所有模式
        patterns = manager.list_patterns()
        print(f"所有模式 ({len(patterns)} 个):")
        for pattern in patterns:
            print(f"  - {pattern}")
    elif args.stats:
        # 显示统计信息
        stats = manager.get_statistics()
        print(f"统计信息:")
        print(f"  总模式数: {stats['total_patterns']}")
        print(f"  总关键词数: {stats['total_keywords']}")
        print(f"  按类别分布: {stats['patterns_by_category']}")
        print(f"  权重分布: {stats['weight_distribution']}")
    elif args.validate:
        # 验证数据完整性
        errors = manager.validate_data()
        if errors:
            print(f"发现 {len(errors)} 个错误:")
            for error in errors:
                print(f"  ❌ {error}")
        else:
            print("✓ 数据验证通过，没有发现错误")
    else:
        # 默认启动交互式模式
        interactive_mode()

if __name__ == "__main__":
    """
    程序入口点
    
    当直接运行此文件时，会执行主函数。
    支持多种运行方式：
    1. 直接运行：python keyword_manager.py
    2. 交互模式：python keyword_manager.py --interactive
    3. 命令行模式：python keyword_manager.py --list
    4. 验证模式：python keyword_manager.py --validate
    
    这个工具是规则库管理的核心组件，提供了完整的CRUD操作和数据分析功能。
    """
    main()
